package tests;
import junit.framework.Assert;

import org.junit.*;

import shapeclassifier.ShapeClassifier;
import static org.junit.Assert.*;

public class ShapeClassifierTwoWiseTest {

	ShapeClassifier c = new ShapeClassifier();

	@Test
	public void test_twowise1() {
	System.out.println("======================== Test Case twowise1 ========================\n");
	System.out.println("Input: [Equilateral,Large,Yes,84,84,84,84]\n");
	System.out.println("Expected Output: [No: Suggestion=Square]\n");
	assertEquals("Check ", "No: Suggestion=Square", c.evaluateGuess("Equilateral,Large,Yes,84,84,84,84"));
	}
	@Test
	public void test_twowise2() {
	System.out.println("======================== Test Case twowise2 ========================\n");
	System.out.println("Input: [Square,Small,No,3,3]\n");
	System.out.println("Expected Output: [No: Suggestion=Circle]\n");
	assertEquals("Check ", "No: Suggestion=Circle", c.evaluateGuess("Square,Small,No,3,3"));
	}
	@Test
	public void test_twowise3() {
	System.out.println("======================== Test Case twowise3 ========================\n");
	System.out.println("Input: [Ellipse,Large,No,19,12,19,12]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Ellipse,Large,No,19,12,19,12"));
	}
	@Test
	public void test_twowise4() {
	System.out.println("======================== Test Case twowise4 ========================\n");
	System.out.println("Input: [Rectangle,Small,Yes,3675,2521,2521]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Rectangle,Small,Yes,3675,2521,2521"));
	}
	@Test
	public void test_twowise5() {
	System.out.println("======================== Test Case twowise5 ========================\n");
	System.out.println("Input: [Scalene,Small,No,2148]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Scalene,Small,No,2148"));
	}
	@Test
	public void test_twowise6() {
	System.out.println("======================== Test Case twowise6 ========================\n");
	System.out.println("Input: [Circle,Large,Yes,13,15,9]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Circle,Large,Yes,13,15,9"));
	}
	@Test
	public void test_twowise7() {
	System.out.println("======================== Test Case twowise7 ========================\n");
	System.out.println("Input: [Isosceles,Small,No,11,3,7]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle", c.evaluateGuess("Isosceles,Small,No,11,3,7"));
	}
	@Test
	public void test_twowise8() {
	System.out.println("======================== Test Case twowise8 ========================\n");
	System.out.println("Input: [Line,Large,Yes,574,574,918]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles1]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles1", c.evaluateGuess("Line,Large,Yes,574,574,918"));
	}
	@Test
	public void test_twowise9() {
	System.out.println("======================== Test Case twowise9 ========================\n");
	System.out.println("Input: [Isosceles,Large,Yes,1891,3153,3151,3877]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Rectangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Rectangle, Wrong Even/Odd", c.evaluateGuess("Isosceles,Large,Yes,1891,3153,3151,3877"));
	}
	@Test
	public void test_twowise10() {
	System.out.println("======================== Test Case twowise10 ========================\n");
	System.out.println("Input: [Line,Small,No,15,13]\n");
	System.out.println("Expected Output: [No: Suggestion=Ellipse]\n");
	assertEquals("Check ", "No: Suggestion=Ellipse", c.evaluateGuess("Line,Small,No,15,13"));
	}
	@Test
	public void test_twowise11() {
	System.out.println("======================== Test Case twowise11 ========================\n");
	System.out.println("Input: [Scalene,Large,Yes,27,11,51]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Scalene,Large,Yes,27,11,51"));
	}
	@Test
	public void test_twowise12() {
	System.out.println("======================== Test Case twowise12 ========================\n");
	System.out.println("Input: [Ellipse,Small,Yes,545,545,545]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Ellipse,Small,Yes,545,545,545"));
	}
	@Test
	public void test_twowise13() {
	System.out.println("======================== Test Case twowise13 ========================\n");
	System.out.println("Input: [Circle,Small,No,2326,2876,2326]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Circle,Small,No,2326,2876,2326"));
	}
	@Test
	public void test_twowise14() {
	System.out.println("======================== Test Case twowise14 ========================\n");
	System.out.println("Input: [Equilateral,Small,No,5,19,9]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle", c.evaluateGuess("Equilateral,Small,No,5,19,9"));
	}
	@Test
	public void test_twowise15() {
	System.out.println("======================== Test Case twowise15 ========================\n");
	System.out.println("Input: [Rectangle,Large,No,14,16,16]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Rectangle,Large,No,14,16,16"));
	}
	@Test
	public void test_twowise16() {
	System.out.println("======================== Test Case twowise16 ========================\n");
	System.out.println("Input: [Square,Large,Yes,588,4037]\n");
	System.out.println("Expected Output: [No: Suggestion=Ellipse]\n");
	assertEquals("Check ", "No: Suggestion=Ellipse", c.evaluateGuess("Square,Large,Yes,588,4037"));
	}
	@Test
	public void test_twowise17() {
	System.out.println("======================== Test Case twowise17 ========================\n");
	System.out.println("Input: [Isosceles,Small,No,242,630,493]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Isosceles,Small,No,242,630,493"));
	}
	@Test
	public void test_twowise18() {
	System.out.println("======================== Test Case twowise18 ========================\n");
	System.out.println("Input: [Rectangle,Large,Yes,1526,4075,2534]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle", c.evaluateGuess("Rectangle,Large,Yes,1526,4075,2534"));
	}
	@Test
	public void test_twowise19() {
	System.out.println("======================== Test Case twowise19 ========================\n");
	System.out.println("Input: [Ellipse,Small,No,2,10,10,11]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Rectangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Rectangle, Wrong Even/Odd", c.evaluateGuess("Ellipse,Small,No,2,10,10,11"));
	}
	@Test
	public void test_twowise20() {
	System.out.println("======================== Test Case twowise20 ========================\n");
	System.out.println("Input: [Rectangle,Large,No,30,30,30]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Rectangle,Large,No,30,30,30"));
	}
	@Test
	public void test_twowise21() {
	System.out.println("======================== Test Case twowise21 ========================\n");
	System.out.println("Input: [Rectangle,Small,No,15,15,17]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles1]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles1", c.evaluateGuess("Rectangle,Small,No,15,15,17"));
	}
	@Test
	public void test_twowise22() {
	System.out.println("======================== Test Case twowise22 ========================\n");
	System.out.println("Input: [Equilateral,Large,Yes,3312,3312]\n");
	System.out.println("Expected Output: [No: Suggestion=Circle]\n");
	assertEquals("Check ", "No: Suggestion=Circle", c.evaluateGuess("Equilateral,Large,Yes,3312,3312"));
	}
	@Test
	public void test_twowise23() {
	System.out.println("======================== Test Case twowise23 ========================\n");
	System.out.println("Input: [Circle,Large,Yes,4011,372,3462]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle", c.evaluateGuess("Circle,Large,Yes,4011,372,3462"));
	}
	@Test
	public void test_twowise24() {
	System.out.println("======================== Test Case twowise24 ========================\n");
	System.out.println("Input: [Square,Small,Yes,9,5,9,5]\n");
	System.out.println("Expected Output: [No: Suggestion=Rectangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Rectangle, Wrong Even/Odd", c.evaluateGuess("Square,Small,Yes,9,5,9,5"));
	}
	@Test
	public void test_twowise25() {
	System.out.println("======================== Test Case twowise25 ========================\n");
	System.out.println("Input: [Circle,Large,Yes,5]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Circle,Large,Yes,5"));
	}
	@Test
	public void test_twowise26() {
	System.out.println("======================== Test Case twowise26 ========================\n");
	System.out.println("Input: [Square,Small,No,13,13,13,13]\n");
	System.out.println("Expected Output: [Yes: ]\n");
	assertEquals("Check ", "Yes: ", c.evaluateGuess("Square,Small,No,13,13,13,13"));
	}
	@Test
	public void test_twowise27() {
	System.out.println("======================== Test Case twowise27 ========================\n");
	System.out.println("Input: [Equilateral,Small,No,2516,1243,3790]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Equilateral,Small,No,2516,1243,3790"));
	}
	@Test
	public void test_twowise28() {
	System.out.println("======================== Test Case twowise28 ========================\n");
	System.out.println("Input: [Rectangle,Large,Yes,35,13,35]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Rectangle,Large,Yes,35,13,35"));
	}
	@Test
	public void test_twowise29() {
	System.out.println("======================== Test Case twowise29 ========================\n");
	System.out.println("Input: [Equilateral,Small,Yes,3973,3063,3973,3063]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Equilateral,Small,Yes,3973,3063,3973,3063"));
	}
	@Test
	public void test_twowise30() {
	System.out.println("======================== Test Case twowise30 ========================\n");
	System.out.println("Input: [Line,Large,Yes,5,21,21]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Line,Large,Yes,5,21,21"));
	}
	@Test
	public void test_twowise31() {
	System.out.println("======================== Test Case twowise31 ========================\n");
	System.out.println("Input: [Scalene,Large,Yes,855,3865,855,3865]\n");
	System.out.println("Expected Output: [No: Suggestion=Rectangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Rectangle, Wrong Even/Odd", c.evaluateGuess("Scalene,Large,Yes,855,3865,855,3865"));
	}
	@Test
	public void test_twowise32() {
	System.out.println("======================== Test Case twowise32 ========================\n");
	System.out.println("Input: [Isosceles,Large,No,24,32,5]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Isosceles,Large,No,24,32,5"));
	}
	@Test
	public void test_twowise33() {
	System.out.println("======================== Test Case twowise33 ========================\n");
	System.out.println("Input: [Equilateral,Large,No,26]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Equilateral,Large,No,26"));
	}
	@Test
	public void test_twowise34() {
	System.out.println("======================== Test Case twowise34 ========================\n");
	System.out.println("Input: [Square,Large,No,1246,953,2634]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Square,Large,No,1246,953,2634"));
	}
	@Test
	public void test_twowise35() {
	System.out.println("======================== Test Case twowise35 ========================\n");
	System.out.println("Input: [Line,Small,Yes,2687,2687]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Line,Small,Yes,2687,2687"));
	}
	@Test
	public void test_twowise36() {
	System.out.println("======================== Test Case twowise36 ========================\n");
	System.out.println("Input: [Circle,Large,Yes,3,3,3]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Circle,Large,Yes,3,3,3"));
	}
	@Test
	public void test_twowise37() {
	System.out.println("======================== Test Case twowise37 ========================\n");
	System.out.println("Input: [Square,Large,No,3469,3775,3775]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles2]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles2", c.evaluateGuess("Square,Large,No,3469,3775,3775"));
	}
	@Test
	public void test_twowise38() {
	System.out.println("======================== Test Case twowise38 ========================\n");
	System.out.println("Input: [Scalene,Small,Yes,32,32,32]\n");
	System.out.println("Expected Output: [No: Suggestion=Equilateral]\n");
	assertEquals("Check ", "No: Suggestion=Equilateral", c.evaluateGuess("Scalene,Small,Yes,32,32,32"));
	}
	@Test
	public void test_twowise39() {
	System.out.println("======================== Test Case twowise39 ========================\n");
	System.out.println("Input: [Square,Small,Yes,7,3,7]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles3, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles3, Wrong Even/Odd", c.evaluateGuess("Square,Small,Yes,7,3,7"));
	}
	@Test
	public void test_twowise40() {
	System.out.println("======================== Test Case twowise40 ========================\n");
	System.out.println("Input: [Equilateral,Large,No,332,639,3719,2661]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Rectangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Rectangle, Wrong Even/Odd", c.evaluateGuess("Equilateral,Large,No,332,639,3719,2661"));
	}
	@Test
	public void test_twowise41() {
	System.out.println("======================== Test Case twowise41 ========================\n");
	System.out.println("Input: [Ellipse,Large,No,787,787,787,787]\n");
	System.out.println("Expected Output: [No: Suggestion=Square]\n");
	assertEquals("Check ", "No: Suggestion=Square", c.evaluateGuess("Ellipse,Large,No,787,787,787,787"));
	}
	@Test
	public void test_twowise42() {
	System.out.println("======================== Test Case twowise42 ========================\n");
	System.out.println("Input: [Ellipse,Small,No,32,10,4]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Ellipse,Small,No,32,10,4"));
	}
	@Test
	public void test_twowise43() {
	System.out.println("======================== Test Case twowise43 ========================\n");
	System.out.println("Input: [Line,Large,Yes,5,34,32]\n");
	System.out.println("Expected Output: [No: Suggestion=Scalene, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Scalene, Wrong Size", c.evaluateGuess("Line,Large,Yes,5,34,32"));
	}
	@Test
	public void test_twowise44() {
	System.out.println("======================== Test Case twowise44 ========================\n");
	System.out.println("Input: [Isosceles,Large,No,16,13,13]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Isosceles,Large,No,16,13,13"));
	}
	@Test
	public void test_twowise45() {
	System.out.println("======================== Test Case twowise45 ========================\n");
	System.out.println("Input: [Isosceles,Large,No,30,30,26]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Isosceles,Large,No,30,30,26"));
	}
	@Test
	public void test_twowise46() {
	System.out.println("======================== Test Case twowise46 ========================\n");
	System.out.println("Input: [Scalene,Large,No,9,9]\n");
	System.out.println("Expected Output: [No: Suggestion=Circle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Circle, Wrong Size", c.evaluateGuess("Scalene,Large,No,9,9"));
	}
	@Test
	public void test_twowise47() {
	System.out.println("======================== Test Case twowise47 ========================\n");
	System.out.println("Input: [Scalene,Large,No,1878,2707]\n");
	System.out.println("Expected Output: [No: Suggestion=Ellipse, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Ellipse, Wrong Even/Odd", c.evaluateGuess("Scalene,Large,No,1878,2707"));
	}
	@Test
	public void test_twowise48() {
	System.out.println("======================== Test Case twowise48 ========================\n");
	System.out.println("Input: [Equilateral,Small,Yes,51,18,28]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle", c.evaluateGuess("Equilateral,Small,Yes,51,18,28"));
	}
	@Test
	public void test_twowise49() {
	System.out.println("======================== Test Case twowise49 ========================\n");
	System.out.println("Input: [Line,Small,No,3620,3620,3620,3620]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Line,Small,No,3620,3620,3620,3620"));
	}
	@Test
	public void test_twowise50() {
	System.out.println("======================== Test Case twowise50 ========================\n");
	System.out.println("Input: [Ellipse,Small,No,2640,2442,2640]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Ellipse,Small,No,2640,2442,2640"));
	}
	@Test
	public void test_twowise51() {
	System.out.println("======================== Test Case twowise51 ========================\n");
	System.out.println("Input: [Circle,Large,Yes,14,14]\n");
	System.out.println("Expected Output: [No: Wrong Size]\n");
	assertEquals("Check ", "No: Wrong Size", c.evaluateGuess("Circle,Large,Yes,14,14"));
	}
	@Test
	public void test_twowise52() {
	System.out.println("======================== Test Case twowise52 ========================\n");
	System.out.println("Input: [Rectangle,Small,No,1517,503,2037]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Size", c.evaluateGuess("Rectangle,Small,No,1517,503,2037"));
	}
	@Test
	public void test_twowise53() {
	System.out.println("======================== Test Case twowise53 ========================\n");
	System.out.println("Input: [Line,Small,Yes,9]\n");
	System.out.println("Expected Output: [No: Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Wrong Even/Odd", c.evaluateGuess("Line,Small,Yes,9"));
	}
	@Test
	public void test_twowise54() {
	System.out.println("======================== Test Case twowise54 ========================\n");
	System.out.println("Input: [Circle,Large,Yes,3,3]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Circle,Large,Yes,3,3"));
	}
	@Test
	public void test_twowise55() {
	System.out.println("======================== Test Case twowise55 ========================\n");
	System.out.println("Input: [Scalene,Small,Yes,38,37,22]\n");
	System.out.println("Expected Output: [Yes: ]\n");
	assertEquals("Check ", "Yes: ", c.evaluateGuess("Scalene,Small,Yes,38,37,22"));
	}
	@Test
	public void test_twowise56() {
	System.out.println("======================== Test Case twowise56 ========================\n");
	System.out.println("Input: [Isosceles,Small,No,2998,2998,2998,2998]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Isosceles,Small,No,2998,2998,2998,2998"));
	}
	@Test
	public void test_twowise57() {
	System.out.println("======================== Test Case twowise57 ========================\n");
	System.out.println("Input: [Rectangle,Large,Yes,3061,1207,1336]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle", c.evaluateGuess("Rectangle,Large,Yes,3061,1207,1336"));
	}
	@Test
	public void test_twowise58() {
	System.out.println("======================== Test Case twowise58 ========================\n");
	System.out.println("Input: [Ellipse,Small,No,3,19,15]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle", c.evaluateGuess("Ellipse,Small,No,3,19,15"));
	}
	@Test
	public void test_twowise59() {
	System.out.println("======================== Test Case twowise59 ========================\n");
	System.out.println("Input: [Square,Small,Yes,3635,1541,594,370]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Rectangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Rectangle, Wrong Size", c.evaluateGuess("Square,Small,Yes,3635,1541,594,370"));
	}
	@Test
	public void test_twowise60() {
	System.out.println("======================== Test Case twowise60 ========================\n");
	System.out.println("Input: [Equilateral,Small,Yes,752,752,702]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles1, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles1, Wrong Size", c.evaluateGuess("Equilateral,Small,Yes,752,752,702"));
	}
	@Test
	public void test_twowise61() {
	System.out.println("======================== Test Case twowise61 ========================\n");
	System.out.println("Input: [Isosceles,Large,Yes,1204,2300]\n");
	System.out.println("Expected Output: [No: Suggestion=Ellipse]\n");
	assertEquals("Check ", "No: Suggestion=Ellipse", c.evaluateGuess("Isosceles,Large,Yes,1204,2300"));
	}
	@Test
	public void test_twowise62() {
	System.out.println("======================== Test Case twowise62 ========================\n");
	System.out.println("Input: [Line,Small,Yes,3471,2381,3471,2381]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Line,Small,Yes,3471,2381,3471,2381"));
	}
	@Test
	public void test_twowise63() {
	System.out.println("======================== Test Case twowise63 ========================\n");
	System.out.println("Input: [Equilateral,Large,Yes,3263,3263,3263]\n");
	System.out.println("Expected Output: [No: Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Wrong Even/Odd", c.evaluateGuess("Equilateral,Large,Yes,3263,3263,3263"));
	}
	@Test
	public void test_twowise64() {
	System.out.println("======================== Test Case twowise64 ========================\n");
	System.out.println("Input: [Line,Small,Yes,9,5,19]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Line,Small,Yes,9,5,19"));
	}
	@Test
	public void test_twowise65() {
	System.out.println("======================== Test Case twowise65 ========================\n");
	System.out.println("Input: [Ellipse,Large,Yes,12,12]\n");
	System.out.println("Expected Output: [No: Suggestion=Circle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Circle, Wrong Size", c.evaluateGuess("Ellipse,Large,Yes,12,12"));
	}
	@Test
	public void test_twowise66() {
	System.out.println("======================== Test Case twowise66 ========================\n");
	System.out.println("Input: [Scalene,Small,No,3740,3740,2425]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Scalene,Small,No,3740,3740,2425"));
	}
	@Test
	public void test_twowise67() {
	System.out.println("======================== Test Case twowise67 ========================\n");
	System.out.println("Input: [Rectangle,Large,Yes,1079,1167]\n");
	System.out.println("Expected Output: [No: Suggestion=Ellipse, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Ellipse, Wrong Even/Odd", c.evaluateGuess("Rectangle,Large,Yes,1079,1167"));
	}
	@Test
	public void test_twowise68() {
	System.out.println("======================== Test Case twowise68 ========================\n");
	System.out.println("Input: [Circle,Small,Yes,3577,3733,143]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Circle,Small,Yes,3577,3733,143"));
	}
	@Test
	public void test_twowise69() {
	System.out.println("======================== Test Case twowise69 ========================\n");
	System.out.println("Input: [Equilateral,Small,No,13,17,19]\n");
	System.out.println("Expected Output: [No: Suggestion=Scalene]\n");
	assertEquals("Check ", "No: Suggestion=Scalene", c.evaluateGuess("Equilateral,Small,No,13,17,19"));
	}
	@Test
	public void test_twowise70() {
	System.out.println("======================== Test Case twowise70 ========================\n");
	System.out.println("Input: [Scalene,Large,No,7,9,7,1]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Rectangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Rectangle, Wrong Size", c.evaluateGuess("Scalene,Large,No,7,9,7,1"));
	}
	@Test
	public void test_twowise71() {
	System.out.println("======================== Test Case twowise71 ========================\n");
	System.out.println("Input: [Isosceles,Small,Yes,1324]\n");
	System.out.println("Expected Output: [No: Suggestion=Line, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Line, Wrong Size", c.evaluateGuess("Isosceles,Small,Yes,1324"));
	}
	@Test
	public void test_twowise72() {
	System.out.println("======================== Test Case twowise72 ========================\n");
	System.out.println("Input: [Equilateral,Large,Yes,1756,2558,1756]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles3]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles3", c.evaluateGuess("Equilateral,Large,Yes,1756,2558,1756"));
	}
	@Test
	public void test_twowise73() {
	System.out.println("======================== Test Case twowise73 ========================\n");
	System.out.println("Input: [Scalene,Large,No,183,2707,2707]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles2]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles2", c.evaluateGuess("Scalene,Large,No,183,2707,2707"));
	}
	@Test
	public void test_twowise74() {
	System.out.println("======================== Test Case twowise74 ========================\n");
	System.out.println("Input: [Ellipse,Small,No,1757,1757,560]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Ellipse,Small,No,1757,1757,560"));
	}
	@Test
	public void test_twowise75() {
	System.out.println("======================== Test Case twowise75 ========================\n");
	System.out.println("Input: [Square,Large,No,2,11,12]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Square,Large,No,2,11,12"));
	}
	@Test
	public void test_twowise76() {
	System.out.println("======================== Test Case twowise76 ========================\n");
	System.out.println("Input: [Ellipse,Large,Yes,17,23,41]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Ellipse,Large,Yes,17,23,41"));
	}
	@Test
	public void test_twowise77() {
	System.out.println("======================== Test Case twowise77 ========================\n");
	System.out.println("Input: [Circle,Large,Yes,6,6,6,6]\n");
	System.out.println("Expected Output: [No: Suggestion=Square, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Square, Wrong Size", c.evaluateGuess("Circle,Large,Yes,6,6,6,6"));
	}
	@Test
	public void test_twowise78() {
	System.out.println("======================== Test Case twowise78 ========================\n");
	System.out.println("Input: [Scalene,Large,No,2656,3798,191]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Scalene,Large,No,2656,3798,191"));
	}
	@Test
	public void test_twowise79() {
	System.out.println("======================== Test Case twowise79 ========================\n");
	System.out.println("Input: [Rectangle,Small,No,31]\n");
	System.out.println("Expected Output: [No: Suggestion=Line]\n");
	assertEquals("Check ", "No: Suggestion=Line", c.evaluateGuess("Rectangle,Small,No,31"));
	}
	@Test
	public void test_twowise80() {
	System.out.println("======================== Test Case twowise80 ========================\n");
	System.out.println("Input: [Square,Large,Yes,13,13,13]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Square,Large,Yes,13,13,13"));
	}
	@Test
	public void test_twowise81() {
	System.out.println("======================== Test Case twowise81 ========================\n");
	System.out.println("Input: [Rectangle,Small,Yes,361,361,361,361]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Rectangle,Small,Yes,361,361,361,361"));
	}
	@Test
	public void test_twowise82() {
	System.out.println("======================== Test Case twowise82 ========================\n");
	System.out.println("Input: [Circle,Small,No,2937,983,2937,983]\n");
	System.out.println("Expected Output: [No: Suggestion=Rectangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Rectangle, Wrong Size", c.evaluateGuess("Circle,Small,No,2937,983,2937,983"));
	}
	@Test
	public void test_twowise83() {
	System.out.println("======================== Test Case twowise83 ========================\n");
	System.out.println("Input: [Isosceles,Small,No,1871,1871]\n");
	System.out.println("Expected Output: [No: Suggestion=Circle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Circle, Wrong Size", c.evaluateGuess("Isosceles,Small,No,1871,1871"));
	}
	@Test
	public void test_twowise84() {
	System.out.println("======================== Test Case twowise84 ========================\n");
	System.out.println("Input: [Ellipse,Large,No,2575,2195,2195]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles2]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles2", c.evaluateGuess("Ellipse,Large,No,2575,2195,2195"));
	}
	@Test
	public void test_twowise85() {
	System.out.println("======================== Test Case twowise85 ========================\n");
	System.out.println("Input: [Line,Large,Yes,16,4,7]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Size", c.evaluateGuess("Line,Large,Yes,16,4,7"));
	}
	@Test
	public void test_twowise86() {
	System.out.println("======================== Test Case twowise86 ========================\n");
	System.out.println("Input: [Square,Small,Yes,864,560,49]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Size", c.evaluateGuess("Square,Small,Yes,864,560,49"));
	}
	@Test
	public void test_twowise87() {
	System.out.println("======================== Test Case twowise87 ========================\n");
	System.out.println("Input: [Line,Small,No,1673,1419,536,2731]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Line,Small,No,1673,1419,536,2731"));
	}
	@Test
	public void test_twowise88() {
	System.out.println("======================== Test Case twowise88 ========================\n");
	System.out.println("Input: [Line,Small,Yes,3095,2875,3095]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Line,Small,Yes,3095,2875,3095"));
	}
	@Test
	public void test_twowise89() {
	System.out.println("======================== Test Case twowise89 ========================\n");
	System.out.println("Input: [Circle,Large,No,2736,448,2084,3848]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Rectangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Rectangle, Wrong Even/Odd", c.evaluateGuess("Circle,Large,No,2736,448,2084,3848"));
	}
	@Test
	public void test_twowise90() {
	System.out.println("======================== Test Case twowise90 ========================\n");
	System.out.println("Input: [Isosceles,Large,Yes,1860,169,2629]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle", c.evaluateGuess("Isosceles,Large,Yes,1860,169,2629"));
	}
	@Test
	public void test_twowise91() {
	System.out.println("======================== Test Case twowise91 ========================\n");
	System.out.println("Input: [Square,Large,Yes,36,36,15]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles1, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles1, Wrong Size", c.evaluateGuess("Square,Large,Yes,36,36,15"));
	}
	@Test
	public void test_twowise92() {
	System.out.println("======================== Test Case twowise92 ========================\n");
	System.out.println("Input: [Rectangle,Small,No,1389,1407,2599]\n");
	System.out.println("Expected Output: [No: Suggestion=Scalene, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Scalene, Wrong Size", c.evaluateGuess("Rectangle,Small,No,1389,1407,2599"));
	}
	@Test
	public void test_twowise93() {
	System.out.println("======================== Test Case twowise93 ========================\n");
	System.out.println("Input: [Isosceles,Large,Yes,14,14,14]\n");
	System.out.println("Expected Output: [No: Suggestion=Equilateral, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Equilateral, Wrong Size", c.evaluateGuess("Isosceles,Large,Yes,14,14,14"));
	}
	@Test
	public void test_twowise94() {
	System.out.println("======================== Test Case twowise94 ========================\n");
	System.out.println("Input: [Square,Large,No,22]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Square,Large,No,22"));
	}
	@Test
	public void test_twowise95() {
	System.out.println("======================== Test Case twowise95 ========================\n");
	System.out.println("Input: [Rectangle,Small,Yes,13,47,27,9]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Rectangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Rectangle, Wrong Even/Odd", c.evaluateGuess("Rectangle,Small,Yes,13,47,27,9"));
	}
	@Test
	public void test_twowise96() {
	System.out.println("======================== Test Case twowise96 ========================\n");
	System.out.println("Input: [Scalene,Small,Yes,300,187,300]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles3, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles3, Wrong Size", c.evaluateGuess("Scalene,Small,Yes,300,187,300"));
	}
	@Test
	public void test_twowise97() {
	System.out.println("======================== Test Case twowise97 ========================\n");
	System.out.println("Input: [Line,Small,No,1823,4087,2163]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Size", c.evaluateGuess("Line,Small,No,1823,4087,2163"));
	}
	@Test
	public void test_twowise98() {
	System.out.println("======================== Test Case twowise98 ========================\n");
	System.out.println("Input: [Ellipse,Small,No,7,1]\n");
	System.out.println("Expected Output: [Yes: ]\n");
	assertEquals("Check ", "Yes: ", c.evaluateGuess("Ellipse,Small,No,7,1"));
	}
	@Test
	public void test_twowise99() {
	System.out.println("======================== Test Case twowise99 ========================\n");
	System.out.println("Input: [Circle,Small,No,2867,2867,219]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles1, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles1, Wrong Size", c.evaluateGuess("Circle,Small,No,2867,2867,219"));
	}
	@Test
	public void test_twowise100() {
	System.out.println("======================== Test Case twowise100 ========================\n");
	System.out.println("Input: [Circle,Large,Yes,3159,3794,3794]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles2]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles2", c.evaluateGuess("Circle,Large,Yes,3159,3794,3794"));
	}
	@Test
	public void test_twowise101() {
	System.out.println("======================== Test Case twowise101 ========================\n");
	System.out.println("Input: [Rectangle,Large,Yes,735,45,735,45]\n");
	System.out.println("Expected Output: [No: Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Wrong Even/Odd", c.evaluateGuess("Rectangle,Large,Yes,735,45,735,45"));
	}
	@Test
	public void test_twowise102() {
	System.out.println("======================== Test Case twowise102 ========================\n");
	System.out.println("Input: [Equilateral,Small,No,8,18]\n");
	System.out.println("Expected Output: [No: Suggestion=Ellipse, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Ellipse, Wrong Even/Odd", c.evaluateGuess("Equilateral,Small,No,8,18"));
	}
	@Test
	public void test_twowise103() {
	System.out.println("======================== Test Case twowise103 ========================\n");
	System.out.println("Input: [Ellipse,Large,No,4050]\n");
	System.out.println("Expected Output: [No: Suggestion=Line, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Line, Wrong Even/Odd", c.evaluateGuess("Ellipse,Large,No,4050"));
	}
	@Test
	public void test_twowise104() {
	System.out.println("======================== Test Case twowise104 ========================\n");
	System.out.println("Input: [Scalene,Small,No,25,2,15]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Scalene,Small,No,25,2,15"));
	}
	@Test
	public void test_twowise105() {
	System.out.println("======================== Test Case twowise105 ========================\n");
	System.out.println("Input: [Rectangle,Large,Yes,1845,1845]\n");
	System.out.println("Expected Output: [No: Suggestion=Circle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Circle, Wrong Even/Odd", c.evaluateGuess("Rectangle,Large,Yes,1845,1845"));
	}
	@Test
	public void test_twowise106() {
	System.out.println("======================== Test Case twowise106 ========================\n");
	System.out.println("Input: [Isosceles,Small,No,2,3,2,3]\n");
	System.out.println("Expected Output: [No: Suggestion=Rectangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Rectangle, Wrong Even/Odd", c.evaluateGuess("Isosceles,Small,No,2,3,2,3"));
	}
	@Test
	public void test_twowise107() {
	System.out.println("======================== Test Case twowise107 ========================\n");
	System.out.println("Input: [Equilateral,Small,No,1,47,47]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles2]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles2", c.evaluateGuess("Equilateral,Small,No,1,47,47"));
	}
	@Test
	public void test_twowise108() {
	System.out.println("======================== Test Case twowise108 ========================\n");
	System.out.println("Input: [Isosceles,Large,Yes,11,13,11]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Isosceles,Large,Yes,11,13,11"));
	}
	@Test
	public void test_twowise109() {
	System.out.println("======================== Test Case twowise109 ========================\n");
	System.out.println("Input: [Ellipse,Small,Yes,18,24,30]\n");
	System.out.println("Expected Output: [No: Suggestion=Scalene]\n");
	assertEquals("Check ", "No: Suggestion=Scalene", c.evaluateGuess("Ellipse,Small,Yes,18,24,30"));
	}
	@Test
	public void test_twowise110() {
	System.out.println("======================== Test Case twowise110 ========================\n");
	System.out.println("Input: [Square,Large,Yes,137,2677,2523]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Square,Large,Yes,137,2677,2523"));
	}
	@Test
	public void test_twowise111() {
	System.out.println("======================== Test Case twowise111 ========================\n");
	System.out.println("Input: [Scalene,Large,Yes,1820,1820,1820,1820]\n");
	System.out.println("Expected Output: [No: Suggestion=Square]\n");
	assertEquals("Check ", "No: Suggestion=Square", c.evaluateGuess("Scalene,Large,Yes,1820,1820,1820,1820"));
	}
	@Test
	public void test_twowise112() {
	System.out.println("======================== Test Case twowise112 ========================\n");
	System.out.println("Input: [Line,Large,Yes,602,602,602]\n");
	System.out.println("Expected Output: [No: Suggestion=Equilateral]\n");
	assertEquals("Check ", "No: Suggestion=Equilateral", c.evaluateGuess("Line,Large,Yes,602,602,602"));
	}
	@Test
	public void test_twowise113() {
	System.out.println("======================== Test Case twowise113 ========================\n");
	System.out.println("Input: [Circle,Large,No,487,729,3276]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Circle,Large,No,487,729,3276"));
	}

	
	@Test
	public void test_81() {
		String actualOutput = c.evaluateGuess("Rectangle,Large,Yes,100,200,200,100");
		assertEquals("No", actualOutput);
	}
	
	@Test
	public void test_82() {
		String actualOutput = c.evaluateGuess("Equilateral,Large,Yes ,100,100,100");
		assertEquals("No", actualOutput);
	}
	
	@org.junit.Test
	public void test001() {
		Assert.assertEquals(null, c.evaluateGuess("Isosceles,Small,No,2854,2373"));
	}

	@org.junit.Test
	public void test002() {
		Assert.assertEquals(null, c.evaluateGuess("13223.424513,13223.424513,13223.424513,3977,2491,520.460197360003,1266"));
	}

	@org.junit.Test
	public void test003() {
		Assert.assertEquals(null, c.evaluateGuess("Scalene,Diamond,No,3557,9714,1306,2623"));
	}

	@org.junit.Test
	public void test004() {
		Assert.assertEquals(null, c.evaluateGuess("Ellipse,Small,##@$@#$%#%,-1,3325"));
	}

	@org.junit.Test
	public void test005() {
		Assert.assertEquals(null, c.evaluateGuess("Diamond,Small,No,Diamond,3740,1963"));
	}

	@org.junit.Test
	public void test006() {
		Assert.assertEquals(null, c.evaluateGuess("Circle,13223.424513,13223.424513,13223.424513"));
	}

	@org.junit.Test
	public void test007() {
		Assert.assertEquals(null, c.evaluateGuess("Equilateral,Small,Diamond,1070,1946,2331,735"));
	}

	@org.junit.Test
	public void test008() {
		Assert.assertEquals(null, c.evaluateGuess("Isosceles,Diamond,Yes,886,3907,3190"));
	}

	@org.junit.Test
	public void test009() {
		Assert.assertEquals(null, c.evaluateGuess("Circle,,No,-1"));
	}

	@org.junit.Test
	public void test010() {
		Assert.assertEquals(null, c.evaluateGuess("Isosceles,Large,Yes,3079.67522060484,88"));
	}

	@org.junit.Test
	public void test011() {
		Assert.assertEquals(null, c.evaluateGuess("Circle,Small,,7023,274"));
	}

	@org.junit.Test
	public void test012() {
		Assert.assertEquals(null, c.evaluateGuess("Ellipse,Large,13223.424513,3131,176,287.623928483866"));
	}

	@org.junit.Test
	public void test013() {
		Assert.assertEquals(null, c.evaluateGuess("13223.424513,Large,,4352"));
	}

	@org.junit.Test
	public void test014() {
		Assert.assertEquals(null, c.evaluateGuess("Ellipse,13223.424513,No,Diamond,4057,3412"));
	}

	@org.junit.Test
	public void test015() {
		Assert.assertEquals(null, c.evaluateGuess("Rectangle,Large,No,374.335360459208,1367,3463,921"));
	}

	@org.junit.Test
	public void test016() {
		Assert.assertEquals(null, c.evaluateGuess("Diamond,##@$@#$%#%,,0,2964,691,2822"));
	}

	@org.junit.Test
	public void test017() {
		Assert.assertEquals(null, c.evaluateGuess("Line,13223.424513,No,"));
	}

	@org.junit.Test
	public void test018() {
		Assert.assertEquals(null, c.evaluateGuess("Diamond,##@$@#$%#%,,727"));
	}

	@org.junit.Test
	public void test019() {
		Assert.assertEquals(null, c.evaluateGuess("Circle,Small,13223.424513,3850,-1,2714"));
	}

	@org.junit.Test
	public void test020() {
		Assert.assertEquals(null, c.evaluateGuess("Circle,Large,Diamond,7680"));
	}
	
	//testing invalid inputs of the number of params in general
	@org.junit.Test
	public void test021() {
		Assert.assertEquals(null, c.evaluateGuess(" "));
		
	}
	
	//testing invalid inputs of the number of params in general
	@org.junit.Test
	public void test022() {
		Assert.assertEquals(null, c.evaluateGuess("Line"));
		
	}

	//testing invalid inputs of the number of params in general
	@org.junit.Test
	public void test023() {
		Assert.assertEquals(null, c.evaluateGuess("Circle,Small,Yes,45,45,45,45,45,23"));
		
	}

}